home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / net / sch_generic.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  13.0 KB  |  538 lines
  1. #ifndef __NET_SCHED_GENERIC_H
  2. #define __NET_SCHED_GENERIC_H
  3.  
  4. #include <linux/netdevice.h>
  5. #include <linux/types.h>
  6. #include <linux/rcupdate.h>
  7. #include <linux/module.h>
  8. #include <linux/pkt_sched.h>
  9. #include <linux/pkt_cls.h>
  10. #include <net/gen_stats.h>
  11. #include <net/rtnetlink.h>
  12.  
  13. struct Qdisc_ops;
  14. struct qdisc_walker;
  15. struct tcf_walker;
  16. struct module;
  17.  
  18. struct qdisc_rate_table
  19. {
  20.     struct tc_ratespec rate;
  21.     u32        data[256];
  22.     struct qdisc_rate_table *next;
  23.     int        refcnt;
  24. };
  25.  
  26. enum qdisc_state_t
  27. {
  28.     __QDISC_STATE_RUNNING,
  29.     __QDISC_STATE_SCHED,
  30.     __QDISC_STATE_DEACTIVATED,
  31. };
  32.  
  33. struct qdisc_size_table {
  34.     struct list_head    list;
  35.     struct tc_sizespec    szopts;
  36.     int            refcnt;
  37.     u16            data[];
  38. };
  39.  
  40. struct Qdisc
  41. {
  42.     int             (*enqueue)(struct sk_buff *skb, struct Qdisc *dev);
  43.     struct sk_buff *    (*dequeue)(struct Qdisc *dev);
  44.     unsigned        flags;
  45. #define TCQ_F_BUILTIN    1
  46. #define TCQ_F_THROTTLED    2
  47. #define TCQ_F_INGRESS    4
  48.     int            padded;
  49.     struct Qdisc_ops    *ops;
  50.     struct qdisc_size_table    *stab;
  51.     u32            handle;
  52.     u32            parent;
  53.     atomic_t        refcnt;
  54.     unsigned long        state;
  55.     struct sk_buff        *gso_skb;
  56.     struct sk_buff_head    requeue;
  57.     struct sk_buff_head    q;
  58.     struct netdev_queue    *dev_queue;
  59.     struct Qdisc        *next_sched;
  60.     struct list_head    list;
  61.  
  62.     struct gnet_stats_basic    bstats;
  63.     struct gnet_stats_queue    qstats;
  64.     struct gnet_stats_rate_est    rate_est;
  65.     int            (*reshape_fail)(struct sk_buff *skb,
  66.                     struct Qdisc *q);
  67.  
  68.     void            *u32_node;
  69.  
  70.     /* This field is deprecated, but it is still used by CBQ
  71.      * and it will live until better solution will be invented.
  72.      */
  73.     struct Qdisc        *__parent;
  74. };
  75.  
  76. struct Qdisc_class_ops
  77. {
  78.     /* Child qdisc manipulation */
  79.     int            (*graft)(struct Qdisc *, unsigned long cl,
  80.                     struct Qdisc *, struct Qdisc **);
  81.     struct Qdisc *        (*leaf)(struct Qdisc *, unsigned long cl);
  82.     void            (*qlen_notify)(struct Qdisc *, unsigned long);
  83.  
  84.     /* Class manipulation routines */
  85.     unsigned long        (*get)(struct Qdisc *, u32 classid);
  86.     void            (*put)(struct Qdisc *, unsigned long);
  87.     int            (*change)(struct Qdisc *, u32, u32,
  88.                     struct nlattr **, unsigned long *);
  89.     int            (*delete)(struct Qdisc *, unsigned long);
  90.     void            (*walk)(struct Qdisc *, struct qdisc_walker * arg);
  91.  
  92.     /* Filter manipulation */
  93.     struct tcf_proto **    (*tcf_chain)(struct Qdisc *, unsigned long);
  94.     unsigned long        (*bind_tcf)(struct Qdisc *, unsigned long,
  95.                     u32 classid);
  96.     void            (*unbind_tcf)(struct Qdisc *, unsigned long);
  97.  
  98.     /* rtnetlink specific */
  99.     int            (*dump)(struct Qdisc *, unsigned long,
  100.                     struct sk_buff *skb, struct tcmsg*);
  101.     int            (*dump_stats)(struct Qdisc *, unsigned long,
  102.                     struct gnet_dump *);
  103. };
  104.  
  105. struct Qdisc_ops
  106. {
  107.     struct Qdisc_ops    *next;
  108.     const struct Qdisc_class_ops    *cl_ops;
  109.     char            id[IFNAMSIZ];
  110.     int            priv_size;
  111.  
  112.     int             (*enqueue)(struct sk_buff *, struct Qdisc *);
  113.     struct sk_buff *    (*dequeue)(struct Qdisc *);
  114.     int             (*requeue)(struct sk_buff *, struct Qdisc *);
  115.     unsigned int        (*drop)(struct Qdisc *);
  116.  
  117.     int            (*init)(struct Qdisc *, struct nlattr *arg);
  118.     void            (*reset)(struct Qdisc *);
  119.     void            (*destroy)(struct Qdisc *);
  120.     int            (*change)(struct Qdisc *, struct nlattr *arg);
  121.  
  122.     int            (*dump)(struct Qdisc *, struct sk_buff *);
  123.     int            (*dump_stats)(struct Qdisc *, struct gnet_dump *);
  124.  
  125.     struct module        *owner;
  126. };
  127.  
  128.  
  129. struct tcf_result
  130. {
  131.     unsigned long    class;
  132.     u32        classid;
  133. };
  134.  
  135. struct tcf_proto_ops
  136. {
  137.     struct tcf_proto_ops    *next;
  138.     char            kind[IFNAMSIZ];
  139.  
  140.     int            (*classify)(struct sk_buff*, struct tcf_proto*,
  141.                     struct tcf_result *);
  142.     int            (*init)(struct tcf_proto*);
  143.     void            (*destroy)(struct tcf_proto*);
  144.  
  145.     unsigned long        (*get)(struct tcf_proto*, u32 handle);
  146.     void            (*put)(struct tcf_proto*, unsigned long);
  147.     int            (*change)(struct tcf_proto*, unsigned long,
  148.                     u32 handle, struct nlattr **,
  149.                     unsigned long *);
  150.     int            (*delete)(struct tcf_proto*, unsigned long);
  151.     void            (*walk)(struct tcf_proto*, struct tcf_walker *arg);
  152.  
  153.     /* rtnetlink specific */
  154.     int            (*dump)(struct tcf_proto*, unsigned long,
  155.                     struct sk_buff *skb, struct tcmsg*);
  156.  
  157.     struct module        *owner;
  158. };
  159.  
  160. struct tcf_proto
  161. {
  162.     /* Fast access part */
  163.     struct tcf_proto    *next;
  164.     void            *root;
  165.     int            (*classify)(struct sk_buff*, struct tcf_proto*,
  166.                     struct tcf_result *);
  167.     __be16            protocol;
  168.  
  169.     /* All the rest */
  170.     u32            prio;
  171.     u32            classid;
  172.     struct Qdisc        *q;
  173.     void            *data;
  174.     struct tcf_proto_ops    *ops;
  175. };
  176.  
  177. struct qdisc_skb_cb {
  178.     unsigned int        pkt_len;
  179.     char            data[];
  180. };
  181.  
  182. static inline struct qdisc_skb_cb *qdisc_skb_cb(struct sk_buff *skb)
  183. {
  184.     return (struct qdisc_skb_cb *)skb->cb;
  185. }
  186.  
  187. static inline spinlock_t *qdisc_lock(struct Qdisc *qdisc)
  188. {
  189.     return &qdisc->q.lock;
  190. }
  191.  
  192. static inline struct Qdisc *qdisc_root(struct Qdisc *qdisc)
  193. {
  194.     return qdisc->dev_queue->qdisc;
  195. }
  196.  
  197. static inline struct Qdisc *qdisc_root_sleeping(struct Qdisc *qdisc)
  198. {
  199.     return qdisc->dev_queue->qdisc_sleeping;
  200. }
  201.  
  202. /* The qdisc root lock is a mechanism by which to top level
  203.  * of a qdisc tree can be locked from any qdisc node in the
  204.  * forest.  This allows changing the configuration of some
  205.  * aspect of the qdisc tree while blocking out asynchronous
  206.  * qdisc access in the packet processing paths.
  207.  *
  208.  * It is only legal to do this when the root will not change
  209.  * on us.  Otherwise we'll potentially lock the wrong qdisc
  210.  * root.  This is enforced by holding the RTNL semaphore, which
  211.  * all users of this lock accessor must do.
  212.  */
  213. static inline spinlock_t *qdisc_root_lock(struct Qdisc *qdisc)
  214. {
  215.     struct Qdisc *root = qdisc_root(qdisc);
  216.  
  217.     ASSERT_RTNL();
  218.     return qdisc_lock(root);
  219. }
  220.  
  221. static inline spinlock_t *qdisc_root_sleeping_lock(struct Qdisc *qdisc)
  222. {
  223.     struct Qdisc *root = qdisc_root_sleeping(qdisc);
  224.  
  225.     ASSERT_RTNL();
  226.     return qdisc_lock(root);
  227. }
  228.  
  229. static inline struct net_device *qdisc_dev(struct Qdisc *qdisc)
  230. {
  231.     return qdisc->dev_queue->dev;
  232. }
  233.  
  234. static inline void sch_tree_lock(struct Qdisc *q)
  235. {
  236.     spin_lock_bh(qdisc_root_sleeping_lock(q));
  237. }
  238.  
  239. static inline void sch_tree_unlock(struct Qdisc *q)
  240. {
  241.     spin_unlock_bh(qdisc_root_sleeping_lock(q));
  242. }
  243.  
  244. #define tcf_tree_lock(tp)    sch_tree_lock((tp)->q)
  245. #define tcf_tree_unlock(tp)    sch_tree_unlock((tp)->q)
  246.  
  247. extern struct Qdisc noop_qdisc;
  248. extern struct Qdisc_ops noop_qdisc_ops;
  249.  
  250. struct Qdisc_class_common
  251. {
  252.     u32            classid;
  253.     struct hlist_node    hnode;
  254. };
  255.  
  256. struct Qdisc_class_hash
  257. {
  258.     struct hlist_head    *hash;
  259.     unsigned int        hashsize;
  260.     unsigned int        hashmask;
  261.     unsigned int        hashelems;
  262. };
  263.  
  264. static inline unsigned int qdisc_class_hash(u32 id, u32 mask)
  265. {
  266.     id ^= id >> 8;
  267.     id ^= id >> 4;
  268.     return id & mask;
  269. }
  270.  
  271. static inline struct Qdisc_class_common *
  272. qdisc_class_find(struct Qdisc_class_hash *hash, u32 id)
  273. {
  274.     struct Qdisc_class_common *cl;
  275.     struct hlist_node *n;
  276.     unsigned int h;
  277.  
  278.     h = qdisc_class_hash(id, hash->hashmask);
  279.     hlist_for_each_entry(cl, n, &hash->hash[h], hnode) {
  280.         if (cl->classid == id)
  281.             return cl;
  282.     }
  283.     return NULL;
  284. }
  285.  
  286. extern int qdisc_class_hash_init(struct Qdisc_class_hash *);
  287. extern void qdisc_class_hash_insert(struct Qdisc_class_hash *, struct Qdisc_class_common *);
  288. extern void qdisc_class_hash_remove(struct Qdisc_class_hash *, struct Qdisc_class_common *);
  289. extern void qdisc_class_hash_grow(struct Qdisc *, struct Qdisc_class_hash *);
  290. extern void qdisc_class_hash_destroy(struct Qdisc_class_hash *);
  291.  
  292. extern void dev_init_scheduler(struct net_device *dev);
  293. extern void dev_shutdown(struct net_device *dev);
  294. extern void dev_activate(struct net_device *dev);
  295. extern void dev_deactivate(struct net_device *dev);
  296. extern void qdisc_reset(struct Qdisc *qdisc);
  297. extern void qdisc_destroy(struct Qdisc *qdisc);
  298. extern void qdisc_tree_decrease_qlen(struct Qdisc *qdisc, unsigned int n);
  299. extern struct Qdisc *qdisc_alloc(struct netdev_queue *dev_queue,
  300.                  struct Qdisc_ops *ops);
  301. extern struct Qdisc *qdisc_create_dflt(struct net_device *dev,
  302.                        struct netdev_queue *dev_queue,
  303.                        struct Qdisc_ops *ops, u32 parentid);
  304. extern void qdisc_calculate_pkt_len(struct sk_buff *skb,
  305.                    struct qdisc_size_table *stab);
  306. extern void tcf_destroy(struct tcf_proto *tp);
  307. extern void tcf_destroy_chain(struct tcf_proto **fl);
  308.  
  309. /* Reset all TX qdiscs of a device.  */
  310. static inline void qdisc_reset_all_tx(struct net_device *dev)
  311. {
  312.     unsigned int i;
  313.     for (i = 0; i < dev->num_tx_queues; i++)
  314.         qdisc_reset(netdev_get_tx_queue(dev, i)->qdisc);
  315. }
  316.  
  317. /* Are all TX queues of the device empty?  */
  318. static inline bool qdisc_all_tx_empty(const struct net_device *dev)
  319. {
  320.     unsigned int i;
  321.     for (i = 0; i < dev->num_tx_queues; i++) {
  322.         struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  323.         const struct Qdisc *q = txq->qdisc;
  324.  
  325.         if (q->q.qlen)
  326.             return false;
  327.     }
  328.     return true;
  329. }
  330.  
  331. /* Are any of the TX qdiscs changing?  */
  332. static inline bool qdisc_tx_changing(struct net_device *dev)
  333. {
  334.     unsigned int i;
  335.     for (i = 0; i < dev->num_tx_queues; i++) {
  336.         struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  337.         if (txq->qdisc != txq->qdisc_sleeping)
  338.             return true;
  339.     }
  340.     return false;
  341. }
  342.  
  343. /* Is the device using the noop qdisc on all queues?  */
  344. static inline bool qdisc_tx_is_noop(const struct net_device *dev)
  345. {
  346.     unsigned int i;
  347.     for (i = 0; i < dev->num_tx_queues; i++) {
  348.         struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  349.         if (txq->qdisc != &noop_qdisc)
  350.             return false;
  351.     }
  352.     return true;
  353. }
  354.  
  355. static inline unsigned int qdisc_pkt_len(struct sk_buff *skb)
  356. {
  357.     return qdisc_skb_cb(skb)->pkt_len;
  358. }
  359.  
  360. /* additional qdisc xmit flags (NET_XMIT_MASK in linux/netdevice.h) */
  361. enum net_xmit_qdisc_t {
  362.     __NET_XMIT_STOLEN = 0x00010000,
  363.     __NET_XMIT_BYPASS = 0x00020000,
  364. };
  365.  
  366. #ifdef CONFIG_NET_CLS_ACT
  367. #define net_xmit_drop_count(e)    ((e) & __NET_XMIT_STOLEN ? 0 : 1)
  368. #else
  369. #define net_xmit_drop_count(e)    (1)
  370. #endif
  371.  
  372. static inline int qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
  373. {
  374. #ifdef CONFIG_NET_SCHED
  375.     if (sch->stab)
  376.         qdisc_calculate_pkt_len(skb, sch->stab);
  377. #endif
  378.     return sch->enqueue(skb, sch);
  379. }
  380.  
  381. static inline int qdisc_enqueue_root(struct sk_buff *skb, struct Qdisc *sch)
  382. {
  383.     qdisc_skb_cb(skb)->pkt_len = skb->len;
  384.     return qdisc_enqueue(skb, sch) & NET_XMIT_MASK;
  385. }
  386.  
  387. static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
  388.                        struct sk_buff_head *list)
  389. {
  390.     __skb_queue_tail(list, skb);
  391.     sch->qstats.backlog += qdisc_pkt_len(skb);
  392.     sch->bstats.bytes += qdisc_pkt_len(skb);
  393.     sch->bstats.packets++;
  394.  
  395.     return NET_XMIT_SUCCESS;
  396. }
  397.  
  398. static inline int qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch)
  399. {
  400.     return __qdisc_enqueue_tail(skb, sch, &sch->q);
  401. }
  402.  
  403. static inline struct sk_buff *__qdisc_dequeue_head(struct Qdisc *sch,
  404.                            struct sk_buff_head *list)
  405. {
  406.     struct sk_buff *skb = __skb_dequeue(list);
  407.  
  408.     if (likely(skb != NULL))
  409.         sch->qstats.backlog -= qdisc_pkt_len(skb);
  410.  
  411.     return skb;
  412. }
  413.  
  414. static inline struct sk_buff *qdisc_dequeue_head(struct Qdisc *sch)
  415. {
  416.     return __qdisc_dequeue_head(sch, &sch->q);
  417. }
  418.  
  419. static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,
  420.                            struct sk_buff_head *list)
  421. {
  422.     struct sk_buff *skb = __skb_dequeue_tail(list);
  423.  
  424.     if (likely(skb != NULL))
  425.         sch->qstats.backlog -= qdisc_pkt_len(skb);
  426.  
  427.     return skb;
  428. }
  429.  
  430. static inline struct sk_buff *qdisc_dequeue_tail(struct Qdisc *sch)
  431. {
  432.     return __qdisc_dequeue_tail(sch, &sch->q);
  433. }
  434.  
  435. static inline int __qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch,
  436.                   struct sk_buff_head *list)
  437. {
  438.     __skb_queue_head(list, skb);
  439.     sch->qstats.backlog += qdisc_pkt_len(skb);
  440.     sch->qstats.requeues++;
  441.  
  442.     return NET_XMIT_SUCCESS;
  443. }
  444.  
  445. static inline int qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch)
  446. {
  447.     return __qdisc_requeue(skb, sch, &sch->q);
  448. }
  449.  
  450. static inline void __qdisc_reset_queue(struct Qdisc *sch,
  451.                        struct sk_buff_head *list)
  452. {
  453.     /*
  454.      * We do not know the backlog in bytes of this list, it
  455.      * is up to the caller to correct it
  456.      */
  457.     __skb_queue_purge(list);
  458. }
  459.  
  460. static inline void qdisc_reset_queue(struct Qdisc *sch)
  461. {
  462.     __qdisc_reset_queue(sch, &sch->q);
  463.     sch->qstats.backlog = 0;
  464. }
  465.  
  466. static inline unsigned int __qdisc_queue_drop(struct Qdisc *sch,
  467.                           struct sk_buff_head *list)
  468. {
  469.     struct sk_buff *skb = __qdisc_dequeue_tail(sch, list);
  470.  
  471.     if (likely(skb != NULL)) {
  472.         unsigned int len = qdisc_pkt_len(skb);
  473.         kfree_skb(skb);
  474.         return len;
  475.     }
  476.  
  477.     return 0;
  478. }
  479.  
  480. static inline unsigned int qdisc_queue_drop(struct Qdisc *sch)
  481. {
  482.     return __qdisc_queue_drop(sch, &sch->q);
  483. }
  484.  
  485. static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
  486. {
  487.     kfree_skb(skb);
  488.     sch->qstats.drops++;
  489.  
  490.     return NET_XMIT_DROP;
  491. }
  492.  
  493. static inline int qdisc_reshape_fail(struct sk_buff *skb, struct Qdisc *sch)
  494. {
  495.     sch->qstats.drops++;
  496.  
  497. #ifdef CONFIG_NET_CLS_ACT
  498.     if (sch->reshape_fail == NULL || sch->reshape_fail(skb, sch))
  499.         goto drop;
  500.  
  501.     return NET_XMIT_SUCCESS;
  502.  
  503. drop:
  504. #endif
  505.     kfree_skb(skb);
  506.     return NET_XMIT_DROP;
  507. }
  508.  
  509. /* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how
  510.    long it will take to send a packet given its size.
  511.  */
  512. static inline u32 qdisc_l2t(struct qdisc_rate_table* rtab, unsigned int pktlen)
  513. {
  514.     int slot = pktlen + rtab->rate.cell_align + rtab->rate.overhead;
  515.     if (slot < 0)
  516.         slot = 0;
  517.     slot >>= rtab->rate.cell_log;
  518.     if (slot > 255)
  519.         return (rtab->data[255]*(slot >> 8) + rtab->data[slot & 0xFF]);
  520.     return rtab->data[slot];
  521. }
  522.  
  523. #ifdef CONFIG_NET_CLS_ACT
  524. static inline struct sk_buff *skb_act_clone(struct sk_buff *skb, gfp_t gfp_mask)
  525. {
  526.     struct sk_buff *n = skb_clone(skb, gfp_mask);
  527.  
  528.     if (n) {
  529.         n->tc_verd = SET_TC_VERD(n->tc_verd, 0);
  530.         n->tc_verd = CLR_TC_OK2MUNGE(n->tc_verd);
  531.         n->tc_verd = CLR_TC_MUNGED(n->tc_verd);
  532.     }
  533.     return n;
  534. }
  535. #endif
  536.  
  537. #endif
  538.